package sudroid.java.util;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.AbstractList;
import java.util.AbstractMap;
import java.util.AbstractQueue;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Random;
import java.util.RandomAccess;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;

public class Collections
{
  private static final int BINARYSEARCH_THRESHOLD = 5000;
  private static final int COPY_THRESHOLD = 10;
  public static final List EMPTY_LIST;
  public static final Map EMPTY_MAP;
  public static final Set EMPTY_SET = new EmptySet();
  private static final int FILL_THRESHOLD = 25;
  private static final int INDEXOFSUBLIST_THRESHOLD = 35;
  private static final int REPLACEALL_THRESHOLD = 11;
  private static final Comparator REVERSE_ORDER;
  private static final int REVERSE_THRESHOLD = 18;
  private static final int ROTATE_THRESHOLD = 100;
  private static final int SHUFFLE_THRESHOLD = 5;
  private static Random r;

  static
  {
    EMPTY_LIST = new EmptyList();
    EMPTY_MAP = new EmptyMap();
    REVERSE_ORDER = new ReverseComparator();
  }

  public static <T> boolean addAll(Collection<? super T> paramCollection, T[] paramArrayOfT)
  {
    boolean bool1 = false;
    int i = paramArrayOfT.length;
    int j = 0;
    while (true)
    {
      if (j >= i)
        return bool1;
      T ? = paramArrayOfT[j];
      boolean bool2 = paramCollection.add(?);
      bool1 |= bool2;
      j += 1;
    }
  }

  public static <T> Queue<T> asLifoQueue(Deque<T> paramDeque)
  {
    return new AsLIFOQueue();
  }

  public static <T> int binarySearch(List<? extends Comparable<? super T>> paramList, T paramT)
  {
    if (((paramList instanceof RandomAccess)) || (paramList.size() < 5000));
    for (int i = indexedBinarySearch(paramList, paramT); ; i = iteratorBinarySearch(paramList, paramT))
      return i;
  }

  public static <T> int binarySearch(List<? extends T> paramList, T paramT, Comparator<? super T> paramComparator)
  {
    int i;
    if (paramComparator == null)
      i = binarySearch(paramList, paramT);
    while (true)
    {
      return i;
      if (((paramList instanceof RandomAccess)) || (paramList.size() < 5000))
      {
        i = indexedBinarySearch(paramList, paramT, paramComparator);
        continue;
      }
      i = iteratorBinarySearch(paramList, paramT, paramComparator);
    }
  }

  public static <E> Collection<E> checkedCollection(Collection<E> paramCollection, Class<E> paramClass)
  {
    return new CheckedCollection(paramClass);
  }

  public static <E> List<E> checkedList(List<E> paramList, Class<E> paramClass)
  {
    if ((paramList instanceof RandomAccess));
    for (Object localObject = new CheckedRandomAccessList(paramClass); ; localObject = new CheckedList(paramClass))
      return localObject;
  }

  public static <K, V> Map<K, V> checkedMap(Map<K, V> paramMap, Class<K> paramClass, Class<V> paramClass1)
  {
    return new CheckedMap(paramClass, paramClass1);
  }

  public static <E> Set<E> checkedSet(Set<E> paramSet, Class<E> paramClass)
  {
    return new CheckedSet(paramClass);
  }

  public static <K, V> SortedMap<K, V> checkedSortedMap(SortedMap<K, V> paramSortedMap, Class<K> paramClass, Class<V> paramClass1)
  {
    return new CheckedSortedMap(paramClass, paramClass1);
  }

  public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> paramSortedSet, Class<E> paramClass)
  {
    return new CheckedSortedSet(paramClass);
  }

  public static <T> void copy(List<? super T> paramList, List<? extends T> paramList1)
  {
    int i = paramList1.size();
    int j = paramList.size();
    if (i > j)
      throw new IndexOutOfBoundsException("Source does not fit in dest");
    int k;
    if ((i < 10) || (((paramList1 instanceof RandomAccess)) && ((paramList instanceof RandomAccess))))
    {
      k = 0;
      if (k < i);
    }
    while (true)
    {
      return;
      Object localObject1 = paramList1.get(k);
      Object localObject2 = paramList.set(k, localObject1);
      k += 1;
      break;
      ListIterator localListIterator1 = paramList.listIterator();
      ListIterator localListIterator2 = paramList1.listIterator();
      k = 0;
      while (k < i)
      {
        Object localObject3 = localListIterator1.next();
        Object localObject4 = localListIterator2.next();
        localListIterator1.set(localObject4);
        k += 1;
      }
    }
  }

  public static boolean disjoint(Collection<?> paramCollection1, Collection<?> paramCollection2)
  {
    if ((!(paramCollection1 instanceof Set)) || ((paramCollection2 instanceof Set)))
    {
      int i = paramCollection1.size();
      int j = paramCollection2.size();
      if (i <= j);
    }
    else
    {
      Collection<?> localCollection = paramCollection1;
      paramCollection1 = paramCollection2;
      paramCollection2 = localCollection;
    }
    Iterator localIterator = paramCollection1.iterator();
    if (!localIterator.hasNext());
    for (int k = 1; ; k = 0)
    {
      return k;
      Object localObject = k.next();
      if (!paramCollection2.contains(localObject))
        break;
    }
  }

  public static final <T> List<T> emptyList()
  {
    return EMPTY_LIST;
  }

  public static final <K, V> Map<K, V> emptyMap()
  {
    return EMPTY_MAP;
  }

  public static final <T> Set<T> emptySet()
  {
    return EMPTY_SET;
  }

  public static <T> Enumeration<T> enumeration(Collection<T> paramCollection)
  {
    return new Collections.1(paramCollection);
  }

  private static boolean eq(Object paramObject1, Object paramObject2)
  {
    int i;
    if (paramObject1 == null)
      if (paramObject2 == null)
        i = 1;
    while (true)
    {
      return i;
      i = 0;
      continue;
      boolean bool = paramObject1.equals(paramObject2);
    }
  }

  public static <T> void fill(List<? super T> paramList, T paramT)
  {
    int i = paramList.size();
    int j;
    if ((i < 25) || ((paramList instanceof RandomAccess)))
    {
      j = 0;
      if (j < i);
    }
    while (true)
    {
      return;
      Object localObject1 = paramList.set(j, paramT);
      j += 1;
      break;
      ListIterator localListIterator = paramList.listIterator();
      j = 0;
      while (j < i)
      {
        Object localObject2 = localListIterator.next();
        localListIterator.set(paramT);
        j += 1;
      }
    }
  }

  public static int frequency(Collection<?> paramCollection, Object paramObject)
  {
    int i = 0;
    Iterator localIterator;
    if (paramObject == null)
    {
      localIterator = paramCollection.iterator();
      if (localIterator.hasNext());
    }
    while (true)
    {
      return i;
      if (localIterator.next() != null)
        break;
      i += 1;
      break;
      localIterator = paramCollection.iterator();
      while (localIterator.hasNext())
      {
        Object localObject = localIterator.next();
        if (!paramObject.equals(localObject))
          continue;
        i += 1;
      }
    }
  }

  private static <T> T get(ListIterator<? extends T> paramListIterator, int paramInt)
  {
    int i = paramListIterator.nextIndex();
    if (i <= paramInt);
    while (true)
    {
      Object localObject = paramListIterator.next();
      int j = i + 1;
      if (i >= paramInt)
      {
        int k = j;
        while (true)
        {
          return localObject;
          do
          {
            localObject = paramListIterator.previous();
            i += -1;
          }
          while (i > paramInt);
        }
      }
      i = j;
    }
  }

  public static int indexOfSubList(List<?> paramList1, List<?> paramList2)
  {
    int i = paramList1.size();
    int j = paramList2.size();
    int k = i - j;
    int n;
    label53: int i1;
    int i2;
    if ((i < 35) || (((paramList1 instanceof RandomAccess)) && ((paramList2 instanceof RandomAccess))))
    {
      m = 0;
      if (m > k)
      {
        n = -1;
        return n;
      }
      i1 = 0;
      i2 = m;
      while (true)
      {
        if (i1 >= j)
        {
          n = m;
          break label53;
        }
        Object localObject1 = paramList2.get(i1);
        Object localObject2 = paramList1.get(i2);
        if (!eq(localObject1, localObject2))
        {
          m += 1;
          break;
        }
        i1 += 1;
        i2 += 1;
      }
    }
    ListIterator localListIterator1 = paramList1.listIterator();
    int m = 0;
    label141: ListIterator localListIterator2;
    if (m <= k)
    {
      localListIterator2 = paramList2.listIterator();
      i1 = 0;
    }
    while (true)
    {
      if (i1 >= j)
      {
        n = m;
        break label53;
      }
      Object localObject3 = localListIterator2.next();
      Object localObject4 = localListIterator1.next();
      if (!eq(localObject3, localObject4))
      {
        i2 = 0;
        while (true)
        {
          if (i2 >= i1)
          {
            m += 1;
            break label141;
            break;
          }
          Object localObject5 = localListIterator1.previous();
          i2 += 1;
        }
      }
      i1 += 1;
    }
  }

  private static <T> int indexedBinarySearch(List<? extends Comparable<? super T>> paramList, T paramT)
  {
    int i = 0;
    int j = paramList.size() - 1;
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      int n = ((Comparable)paramList.get(m)).compareTo(paramT);
      if (n < 0)
      {
        i = m + 1;
        break;
      }
      if (n <= 0)
        continue;
      j = m - 1;
      break;
    }
  }

  private static <T> int indexedBinarySearch(List<? extends T> paramList, T paramT, Comparator<? super T> paramComparator)
  {
    int i = 0;
    int j = paramList.size() - 1;
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      Object localObject = paramList.get(m);
      int n = paramComparator.compare(localObject, paramT);
      if (n < 0)
      {
        i = m + 1;
        break;
      }
      if (n <= 0)
        continue;
      j = m - 1;
      break;
    }
  }

  private static <T> int iteratorBinarySearch(List<? extends Comparable<? super T>> paramList, T paramT)
  {
    int i = 0;
    int j = paramList.size() - 1;
    ListIterator localListIterator = paramList.listIterator();
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      int n = ((Comparable)get(localListIterator, m)).compareTo(paramT);
      if (n < 0)
      {
        i = m + 1;
        break;
      }
      if (n <= 0)
        continue;
      j = m - 1;
      break;
    }
  }

  private static <T> int iteratorBinarySearch(List<? extends T> paramList, T paramT, Comparator<? super T> paramComparator)
  {
    int i = 0;
    int j = paramList.size() - 1;
    ListIterator localListIterator = paramList.listIterator();
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      Object localObject = get(localListIterator, m);
      int n = paramComparator.compare(localObject, paramT);
      if (n < 0)
      {
        i = m + 1;
        break;
      }
      if (n <= 0)
        continue;
      j = m - 1;
      break;
    }
  }

  public static int lastIndexOfSubList(List<?> paramList1, List<?> paramList2)
  {
    int i = paramList1.size();
    int j = paramList2.size();
    int k = i - j;
    int n;
    if ((i < 35) || ((paramList1 instanceof RandomAccess)))
    {
      m = k;
      if (m < 0)
        n = -1;
    }
    label45: int i1;
    int i2;
    while (true)
    {
      return n;
      i1 = 0;
      i2 = m;
      while (true)
      {
        if (i1 >= j)
        {
          n = m;
          break label45;
        }
        Object localObject1 = paramList2.get(i1);
        Object localObject2 = paramList1.get(i2);
        if (!eq(localObject1, localObject2))
        {
          m += -1;
          break;
        }
        i1 += 1;
        i2 += 1;
      }
      if (k >= 0)
        break label135;
      n = -1;
    }
    label135: ListIterator localListIterator1 = paramList1.listIterator(k);
    int m = k;
    label149: ListIterator localListIterator2;
    if (m >= 0)
    {
      localListIterator2 = paramList2.listIterator();
      i1 = 0;
    }
    while (true)
    {
      if (i1 >= j)
      {
        n = m;
        break label45;
      }
      Object localObject3 = localListIterator2.next();
      Object localObject4 = localListIterator1.next();
      if (!eq(localObject3, localObject4))
      {
        if (m != 0)
          i2 = 0;
        while (true)
        {
          int i3 = i1 + 1;
          if (i2 > i3)
          {
            m += -1;
            break label149;
            break;
          }
          Object localObject5 = localListIterator1.previous();
          i2 += 1;
        }
      }
      i1 += 1;
    }
  }

  public static <T> ArrayList<T> list(Enumeration<T> paramEnumeration)
  {
    ArrayList localArrayList = new ArrayList();
    while (true)
    {
      if (!paramEnumeration.hasMoreElements())
        return localArrayList;
      Object localObject = paramEnumeration.nextElement();
      boolean bool = localArrayList.add(localObject);
    }
  }

  public static <T,  extends Comparable<? super T>> T max(Collection<? extends T> paramCollection)
  {
    Iterator localIterator = paramCollection.iterator();
    Object localObject1 = localIterator.next();
    while (true)
    {
      if (!localIterator.hasNext())
        return localObject1;
      Object localObject2 = localIterator.next();
      if (((Comparable)localObject2).compareTo(localObject1) <= 0)
        continue;
      localObject1 = localObject2;
    }
  }

  public static <T> T max(Collection<? extends T> paramCollection, Comparator<? super T> paramComparator)
  {
    Object localObject1;
    if (paramComparator == null)
    {
      localObject1 = max(paramCollection);
      return localObject1;
    }
    Iterator localIterator = paramCollection.iterator();
    Object localObject2 = localIterator.next();
    while (true)
    {
      if (!localIterator.hasNext())
      {
        localObject1 = localObject2;
        break;
      }
      Object localObject3 = localIterator.next();
      if (paramComparator.compare(localObject3, localObject2) <= 0)
        continue;
      localObject2 = localObject3;
    }
  }

  public static <T,  extends Comparable<? super T>> T min(Collection<? extends T> paramCollection)
  {
    Iterator localIterator = paramCollection.iterator();
    Object localObject1 = localIterator.next();
    while (true)
    {
      if (!localIterator.hasNext())
        return localObject1;
      Object localObject2 = localIterator.next();
      if (((Comparable)localObject2).compareTo(localObject1) >= 0)
        continue;
      localObject1 = localObject2;
    }
  }

  public static <T> T min(Collection<? extends T> paramCollection, Comparator<? super T> paramComparator)
  {
    Object localObject1;
    if (paramComparator == null)
    {
      localObject1 = min(paramCollection);
      return localObject1;
    }
    Iterator localIterator = paramCollection.iterator();
    Object localObject2 = localIterator.next();
    while (true)
    {
      if (!localIterator.hasNext())
      {
        localObject1 = localObject2;
        break;
      }
      Object localObject3 = localIterator.next();
      if (paramComparator.compare(localObject3, localObject2) >= 0)
        continue;
      localObject2 = localObject3;
    }
  }

  public static <T> List<T> nCopies(int paramInt, T paramT)
  {
    if (paramInt < 0)
    {
      String str = "List length = " + paramInt;
      throw new IllegalArgumentException(str);
    }
    return new CopiesList(paramT);
  }

  public static <E> Set<E> newSetFromMap(Map<E, Boolean> paramMap)
  {
    return new SetFromMap();
  }

  public static <T> boolean replaceAll(List<T> paramList, T paramT1, T paramT2)
  {
    int i = 0;
    int j = paramList.size();
    int k;
    if ((j < 11) || ((paramList instanceof RandomAccess)))
      if (paramT1 == null)
      {
        k = 0;
        if (k < j);
      }
    while (true)
    {
      return i;
      if (paramList.get(k) == null)
      {
        Object localObject1 = paramList.set(k, paramT2);
        i = 1;
      }
      k += 1;
      break;
      k = 0;
      while (k < j)
      {
        Object localObject2 = paramList.get(k);
        if (paramT1.equals(localObject2))
        {
          Object localObject3 = paramList.set(k, paramT2);
          i = 1;
        }
        k += 1;
      }
      continue;
      ListIterator localListIterator = paramList.listIterator();
      if (paramT1 == null)
      {
        k = 0;
        while (k < j)
        {
          if (localListIterator.next() == null)
          {
            localListIterator.set(paramT2);
            i = 1;
          }
          k += 1;
        }
        continue;
      }
      k = 0;
      while (k < j)
      {
        Object localObject4 = localListIterator.next();
        if (paramT1.equals(localObject4))
        {
          localListIterator.set(paramT2);
          i = 1;
        }
        k += 1;
      }
    }
  }

  public static void reverse(List<?> paramList)
  {
    int i = paramList.size();
    int j;
    int k;
    int m;
    if ((i < 18) || ((paramList instanceof RandomAccess)))
    {
      j = 0;
      k = i >> 1;
      m = i - 1;
      if (j < k);
    }
    while (true)
    {
      return;
      swap(paramList, j, m);
      j += 1;
      m += -1;
      break;
      ListIterator localListIterator1 = paramList.listIterator();
      ListIterator localListIterator2 = paramList.listIterator(i);
      j = 0;
      k = paramList.size() >> 1;
      while (j < k)
      {
        Object localObject1 = localListIterator1.next();
        Object localObject2 = localListIterator2.previous();
        localListIterator1.set(localObject2);
        localListIterator2.set(localObject1);
        j += 1;
      }
    }
  }

  public static <T> Comparator<T> reverseOrder()
  {
    return REVERSE_ORDER;
  }

  public static <T> Comparator<T> reverseOrder(Comparator<T> paramComparator)
  {
    if (paramComparator == null);
    for (Object localObject = reverseOrder(); ; localObject = new ReverseComparator2())
      return localObject;
  }

  public static void rotate(List<?> paramList, int paramInt)
  {
    if (((paramList instanceof RandomAccess)) || (paramList.size() < 100))
      rotate1(paramList, paramInt);
    while (true)
    {
      return;
      rotate2(paramList, paramInt);
    }
  }

  private static <T> void rotate1(List<T> paramList, int paramInt)
  {
    int i = paramList.size();
    if (i == 0);
    while (true)
    {
      return;
      paramInt %= i;
      if (paramInt < 0)
        paramInt += i;
      if (paramInt == 0)
        continue;
      int j = 0;
      int k = 0;
      while (k != i)
      {
        Object localObject = paramList.get(j);
        int m = j;
        do
        {
          m += paramInt;
          if (m >= i)
            m -= i;
          localObject = paramList.set(m, localObject);
          k += 1;
        }
        while (m != j);
        j += 1;
      }
    }
  }

  private static void rotate2(List<?> paramList, int paramInt)
  {
    int i = paramList.size();
    if (i == 0);
    while (true)
    {
      return;
      int j = -paramInt % i;
      if (j < 0)
        j += i;
      if (j == 0)
        continue;
      reverse(paramList.subList(0, j));
      reverse(paramList.subList(j, i));
      reverse(paramList);
    }
  }

  public static void shuffle(List<?> paramList)
  {
    if (r == null)
      r = new Random();
    Random localRandom = r;
    shuffle(paramList, localRandom);
  }

  public static void shuffle(List<?> paramList, Random paramRandom)
  {
    int i = paramList.size();
    if ((i < 5) || ((paramList instanceof RandomAccess)))
    {
      j = i;
      while (true)
      {
        if (j <= 1)
          return;
        int k = j - 1;
        int m = paramRandom.nextInt(j);
        swap(paramList, k, m);
        j += -1;
      }
    }
    Object[] arrayOfObject = paramList.toArray();
    int j = i;
    while (true)
    {
      if (j <= 1)
      {
        ListIterator localListIterator = paramList.listIterator();
        j = 0;
        while (true)
        {
          int n = arrayOfObject.length;
          if (j >= n)
            break;
          Object localObject1 = localListIterator.next();
          Object localObject2 = arrayOfObject[j];
          localListIterator.set(localObject2);
          j += 1;
        }
      }
      int i1 = j - 1;
      int i2 = paramRandom.nextInt(j);
      swap(arrayOfObject, i1, i2);
      j += -1;
    }
  }

  public static <T> Set<T> singleton(T paramT)
  {
    return new SingletonSet();
  }

  public static <T> List<T> singletonList(T paramT)
  {
    return new SingletonList();
  }

  public static <K, V> Map<K, V> singletonMap(K paramK, V paramV)
  {
    return new SingletonMap(paramV);
  }

  public static <T extends Comparable<? super T>> void sort(List<T> paramList)
  {
    Object[] arrayOfObject = paramList.toArray();
    Arrays.sort(arrayOfObject);
    ListIterator localListIterator = paramList.listIterator();
    int i = 0;
    while (true)
    {
      int j = arrayOfObject.length;
      if (i >= j)
        return;
      Object localObject = localListIterator.next();
      Comparable localComparable = (Comparable)arrayOfObject[i];
      localListIterator.set(localComparable);
      i += 1;
    }
  }

  public static <T> void sort(List<T> paramList, Comparator<? super T> paramComparator)
  {
    Object[] arrayOfObject = paramList.toArray();
    Arrays.sort(arrayOfObject, paramComparator);
    ListIterator localListIterator = paramList.listIterator();
    int i = 0;
    while (true)
    {
      int j = arrayOfObject.length;
      if (i >= j)
        return;
      Object localObject1 = localListIterator.next();
      Object localObject2 = arrayOfObject[i];
      localListIterator.set(localObject2);
      i += 1;
    }
  }

  public static void swap(List<?> paramList, int paramInt1, int paramInt2)
  {
    List<?> localList = paramList;
    Object localObject1 = localList.get(paramInt1);
    Object localObject2 = localList.set(paramInt2, localObject1);
    Object localObject3 = localList.set(paramInt1, localObject2);
  }

  private static void swap(Object[] paramArrayOfObject, int paramInt1, int paramInt2)
  {
    Object localObject1 = paramArrayOfObject[paramInt1];
    Object localObject2 = paramArrayOfObject[paramInt2];
    paramArrayOfObject[paramInt1] = localObject2;
    paramArrayOfObject[paramInt2] = localObject1;
  }

  public static <T> Collection<T> synchronizedCollection(Collection<T> paramCollection)
  {
    return new SynchronizedCollection();
  }

  static <T> Collection<T> synchronizedCollection(Collection<T> paramCollection, Object paramObject)
  {
    return new SynchronizedCollection(paramObject);
  }

  public static <T> List<T> synchronizedList(List<T> paramList)
  {
    if ((paramList instanceof RandomAccess));
    for (Object localObject = new SynchronizedRandomAccessList(); ; localObject = new SynchronizedList())
      return localObject;
  }

  static <T> List<T> synchronizedList(List<T> paramList, Object paramObject)
  {
    if ((paramList instanceof RandomAccess));
    for (Object localObject = new SynchronizedRandomAccessList(paramObject); ; localObject = new SynchronizedList(paramObject))
      return localObject;
  }

  public static <K, V> Map<K, V> synchronizedMap(Map<K, V> paramMap)
  {
    return new SynchronizedMap();
  }

  public static <T> Set<T> synchronizedSet(Set<T> paramSet)
  {
    return new SynchronizedSet();
  }

  static <T> Set<T> synchronizedSet(Set<T> paramSet, Object paramObject)
  {
    return new SynchronizedSet(paramObject);
  }

  public static <K, V> SortedMap<K, V> synchronizedSortedMap(SortedMap<K, V> paramSortedMap)
  {
    return new SynchronizedSortedMap();
  }

  public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> paramSortedSet)
  {
    return new SynchronizedSortedSet();
  }

  public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> paramCollection)
  {
    return new UnmodifiableCollection();
  }

  public static <T> List<T> unmodifiableList(List<? extends T> paramList)
  {
    if ((paramList instanceof RandomAccess));
    for (Object localObject = new UnmodifiableRandomAccessList(); ; localObject = new UnmodifiableList())
      return localObject;
  }

  public static <K, V> Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> paramMap)
  {
    return new UnmodifiableMap();
  }

  public static <T> Set<T> unmodifiableSet(Set<? extends T> paramSet)
  {
    return new UnmodifiableSet();
  }

  public static <K, V> SortedMap<K, V> unmodifiableSortedMap(SortedMap<K, ? extends V> paramSortedMap)
  {
    return new UnmodifiableSortedMap();
  }

  public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> paramSortedSet)
  {
    return new UnmodifiableSortedSet();
  }

  class AsLIFOQueue<E> extends AbstractQueue<E>
    implements Queue<E>, Serializable
  {
    private static final long serialVersionUID = 1802017725587941708L;

    AsLIFOQueue()
    {
    }

    public boolean add(E paramE)
    {
      Collections.this.addFirst(paramE);
      return true;
    }

    public void clear()
    {
      Collections.this.clear();
    }

    public boolean contains(Object paramObject)
    {
      return Collections.this.contains(paramObject);
    }

    public boolean containsAll(Collection<?> paramCollection)
    {
      return Collections.this.containsAll(paramCollection);
    }

    public E element()
    {
      return Collections.this.getFirst();
    }

    public boolean isEmpty()
    {
      return Collections.this.isEmpty();
    }

    public Iterator<E> iterator()
    {
      return Collections.this.iterator();
    }

    public boolean offer(E paramE)
    {
      return Collections.this.offerFirst(paramE);
    }

    public E peek()
    {
      return Collections.this.peekFirst();
    }

    public E poll()
    {
      return Collections.this.pollFirst();
    }

    public E remove()
    {
      return Collections.this.removeFirst();
    }

    public boolean remove(Object paramObject)
    {
      return Collections.this.remove(paramObject);
    }

    public boolean removeAll(Collection<?> paramCollection)
    {
      return Collections.this.removeAll(paramCollection);
    }

    public boolean retainAll(Collection<?> paramCollection)
    {
      return Collections.this.retainAll(paramCollection);
    }

    public int size()
    {
      return Collections.this.size();
    }

    public Object[] toArray()
    {
      return Collections.this.toArray();
    }

    public <T> T[] toArray(T[] paramArrayOfT)
    {
      return Collections.this.toArray(paramArrayOfT);
    }

    public String toString()
    {
      return Collections.this.toString();
    }
  }

  class CheckedCollection<E>
    implements Collection<E>, Serializable
  {
    private static final long serialVersionUID = 1578914078182001775L;
    final Class<E> type;
    private E[] zeroLengthElementArray = null;

    CheckedCollection(Class<E> arg2)
    {
      Object localObject;
      if ((Collections.this == null) || (localObject == null))
        throw new NullPointerException();
      this.type = localObject;
    }

    public boolean add(E paramE)
    {
      typeCheck(paramE);
      return Collections.this.add(paramE);
    }

    public boolean addAll(Collection<? extends E> paramCollection)
    {
      Object[] arrayOfObject1 = (Object[])0;
      while (true)
      {
        Object[] arrayOfObject4;
        boolean bool1;
        int j;
        try
        {
          Object[] arrayOfObject2 = zeroLengthElementArray();
          Object[] arrayOfObject3 = paramCollection.toArray(arrayOfObject2);
          arrayOfObject4 = arrayOfObject3;
          bool1 = false;
          int i = arrayOfObject4.length;
          j = 0;
          if (j >= i)
            return bool1;
        }
        catch (ArrayStoreException localArrayStoreException)
        {
          throw new ClassCastException();
        }
        Object localObject = arrayOfObject4[j];
        boolean bool2 = Collections.this.add(localObject);
        bool1 |= bool2;
        j += 1;
      }
    }

    public void clear()
    {
      Collections.this.clear();
    }

    public boolean contains(Object paramObject)
    {
      return Collections.this.contains(paramObject);
    }

    public boolean containsAll(Collection<?> paramCollection)
    {
      return Collections.this.containsAll(paramCollection);
    }

    public boolean isEmpty()
    {
      return Collections.this.isEmpty();
    }

    public Iterator<E> iterator()
    {
      return new Collections.CheckedCollection.1(this);
    }

    public boolean remove(Object paramObject)
    {
      return Collections.this.remove(paramObject);
    }

    public boolean removeAll(Collection<?> paramCollection)
    {
      return Collections.this.removeAll(paramCollection);
    }

    public boolean retainAll(Collection<?> paramCollection)
    {
      return Collections.this.retainAll(paramCollection);
    }

    public int size()
    {
      return Collections.this.size();
    }

    public Object[] toArray()
    {
      return Collections.this.toArray();
    }

    public <T> T[] toArray(T[] paramArrayOfT)
    {
      return Collections.this.toArray(paramArrayOfT);
    }

    public String toString()
    {
      return Collections.this.toString();
    }

    void typeCheck(Object paramObject)
    {
      if (!this.type.isInstance(paramObject))
      {
        StringBuilder localStringBuilder1 = new StringBuilder("Attempt to insert ");
        Class localClass1 = paramObject.getClass();
        StringBuilder localStringBuilder2 = localStringBuilder1.append(localClass1).append(" element into collection with element type ");
        Class localClass2 = this.type;
        String str = localClass2;
        throw new ClassCastException(str);
      }
    }

    E[] zeroLengthElementArray()
    {
      if (this.zeroLengthElementArray == null)
      {
        Object[] arrayOfObject = (Object[])Array.newInstance(this.type, 0);
        this.zeroLengthElementArray = arrayOfObject;
      }
      return this.zeroLengthElementArray;
    }
  }

  class CheckedList<E> extends Collections.CheckedCollection<E>
    implements List<E>
  {
    static final long serialVersionUID = 65247728283967356L;

    CheckedList(Class<E> arg2)
    {
      super(localClass);
    }

    public void add(int paramInt, E paramE)
    {
      typeCheck(paramE);
      Collections.this.add(paramInt, paramE);
    }

    public boolean addAll(int paramInt, Collection<? extends E> paramCollection)
    {
      Object[] arrayOfObject1 = (Object[])0;
      try
      {
        Object[] arrayOfObject2 = zeroLengthElementArray();
        Object[] arrayOfObject3 = paramCollection.toArray(arrayOfObject2);
        Object[] arrayOfObject4 = arrayOfObject3;
        List localList1 = Collections.this;
        List localList2 = Arrays.asList(arrayOfObject4);
        return localList1.addAll(paramInt, localList2);
      }
      catch (ArrayStoreException localArrayStoreException)
      {
      }
      throw new ClassCastException();
    }

    public boolean equals(Object paramObject)
    {
      if ((paramObject != this) && (!Collections.this.equals(paramObject)));
      for (int i = 0; ; i = 1)
        return i;
    }

    public E get(int paramInt)
    {
      return Collections.this.get(paramInt);
    }

    public int hashCode()
    {
      return Collections.this.hashCode();
    }

    public int indexOf(Object paramObject)
    {
      return Collections.this.indexOf(paramObject);
    }

    public int lastIndexOf(Object paramObject)
    {
      return Collections.this.lastIndexOf(paramObject);
    }

    public ListIterator<E> listIterator()
    {
      return listIterator(0);
    }

    public ListIterator<E> listIterator(int paramInt)
    {
      return new Collections.CheckedList.1(this, paramInt);
    }

    public E remove(int paramInt)
    {
      return Collections.this.remove(paramInt);
    }

    public E set(int paramInt, E paramE)
    {
      typeCheck(paramE);
      return Collections.this.set(paramInt, paramE);
    }

    public List<E> subList(int paramInt1, int paramInt2)
    {
      List localList = Collections.this.subList(paramInt1, paramInt2);
      Class localClass = this.type;
      return new CheckedList(localList, localClass);
    }
  }

  class CheckedMap<K, V>
    implements Map<K, V>, Serializable
  {
    private static final long serialVersionUID = 5742860141034234728L;
    private transient Set<Map.Entry<K, V>> entrySet = null;
    final Class<K> keyType;
    final Class<V> valueType;
    private K[] zeroLengthKeyArray = null;
    private V[] zeroLengthValueArray = null;

    CheckedMap(Class<K> paramClass, Class<V> arg3)
    {
      Object localObject;
      if ((Collections.this == null) || (paramClass == null) || (localObject == null))
        throw new NullPointerException();
      this.keyType = paramClass;
      this.valueType = localObject;
    }

    private void typeCheck(Object paramObject1, Object paramObject2)
    {
      if (!this.keyType.isInstance(paramObject1))
      {
        StringBuilder localStringBuilder1 = new StringBuilder("Attempt to insert ");
        Class localClass1 = paramObject1.getClass();
        StringBuilder localStringBuilder2 = localStringBuilder1.append(localClass1).append(" key into collection with key type ");
        Class localClass2 = this.keyType;
        String str1 = localClass2;
        throw new ClassCastException(str1);
      }
      if (!this.valueType.isInstance(paramObject2))
      {
        StringBuilder localStringBuilder3 = new StringBuilder("Attempt to insert ");
        Class localClass3 = paramObject2.getClass();
        StringBuilder localStringBuilder4 = localStringBuilder3.append(localClass3).append(" value into collection with value type ");
        Class localClass4 = this.valueType;
        String str2 = localClass4;
        throw new ClassCastException(str2);
      }
    }

    private K[] zeroLengthKeyArray()
    {
      if (this.zeroLengthKeyArray == null)
      {
        Object[] arrayOfObject = (Object[])Array.newInstance(this.keyType, 0);
        this.zeroLengthKeyArray = arrayOfObject;
      }
      return this.zeroLengthKeyArray;
    }

    private V[] zeroLengthValueArray()
    {
      if (this.zeroLengthValueArray == null)
      {
        Object[] arrayOfObject = (Object[])Array.newInstance(this.valueType, 0);
        this.zeroLengthValueArray = arrayOfObject;
      }
      return this.zeroLengthValueArray;
    }

    public void clear()
    {
      Collections.this.clear();
    }

    public boolean containsKey(Object paramObject)
    {
      return Collections.this.containsKey(paramObject);
    }

    public boolean containsValue(Object paramObject)
    {
      return Collections.this.containsValue(paramObject);
    }

    public Set<Map.Entry<K, V>> entrySet()
    {
      if (this.entrySet == null)
      {
        Set localSet = Collections.this.entrySet();
        Class localClass = this.valueType;
        CheckedEntrySet localCheckedEntrySet = new CheckedEntrySet(localClass);
        this.entrySet = localCheckedEntrySet;
      }
      return this.entrySet;
    }

    public boolean equals(Object paramObject)
    {
      if ((paramObject != this) && (!Collections.this.equals(paramObject)));
      for (int i = 0; ; i = 1)
        return i;
    }

    public V get(Object paramObject)
    {
      return Collections.this.get(paramObject);
    }

    public int hashCode()
    {
      return Collections.this.hashCode();
    }

    public boolean isEmpty()
    {
      return Collections.this.isEmpty();
    }

    public Set<K> keySet()
    {
      return Collections.this.keySet();
    }

    public V put(K paramK, V paramV)
    {
      typeCheck(paramK, paramV);
      return Collections.this.put(paramK, paramV);
    }

    // ERROR //
    public void putAll(Map<? extends K, ? extends V> paramMap)
    {
      // Byte code:
      //   0: iconst_0
      //   1: checkcast 101	[Ljava/lang/Object;
      //   4: astore_2
      //   5: aload_1
      //   6: invokeinterface 134 1 0
      //   11: astore_3
      //   12: aload_0
      //   13: invokespecial 146	sudroid/java/util/Collections$CheckedMap:zeroLengthKeyArray	()[Ljava/lang/Object;
      //   16: astore 4
      //   18: aload_3
      //   19: aload 4
      //   21: invokeinterface 152 2 0
      //   26: astore 5
      //   28: aload 5
      //   30: astore 6
      //   32: iconst_0
      //   33: checkcast 101	[Ljava/lang/Object;
      //   36: astore 7
      //   38: aload_1
      //   39: invokeinterface 156 1 0
      //   44: astore 8
      //   46: aload_0
      //   47: invokespecial 158	sudroid/java/util/Collections$CheckedMap:zeroLengthValueArray	()[Ljava/lang/Object;
      //   50: astore 9
      //   52: aload 8
      //   54: aload 9
      //   56: invokeinterface 161 2 0
      //   61: astore 5
      //   63: aload 5
      //   65: astore 10
      //   67: aload 6
      //   69: arraylength
      //   70: istore 11
      //   72: aload 10
      //   74: arraylength
      //   75: istore 12
      //   77: iload 11
      //   79: iload 12
      //   81: if_icmpeq +31 -> 112
      //   84: new 163	java/util/ConcurrentModificationException
      //   87: dup
      //   88: invokespecial 164	java/util/ConcurrentModificationException:<init>	()V
      //   91: athrow
      //   92: astore 13
      //   94: new 90	java/lang/ClassCastException
      //   97: dup
      //   98: invokespecial 165	java/lang/ClassCastException:<init>	()V
      //   101: athrow
      //   102: astore 14
      //   104: new 90	java/lang/ClassCastException
      //   107: dup
      //   108: invokespecial 165	java/lang/ClassCastException:<init>	()V
      //   111: athrow
      //   112: iconst_0
      //   113: istore 15
      //   115: aload 6
      //   117: arraylength
      //   118: istore 16
      //   120: iload 15
      //   122: iload 16
      //   124: if_icmplt +4 -> 128
      //   127: return
      //   128: aload_0
      //   129: getfield 52	sudroid/java/util/Collections$CheckedMap:m	Ljava/util/Map;
      //   132: astore 17
      //   134: aload 6
      //   136: iload 15
      //   138: aaload
      //   139: astore 18
      //   141: aload 10
      //   143: iload 15
      //   145: aaload
      //   146: astore 19
      //   148: aload 17
      //   150: aload 18
      //   152: aload 19
      //   154: invokeinterface 140 3 0
      //   159: astore 20
      //   161: iload 15
      //   163: iconst_1
      //   164: iadd
      //   165: istore 15
      //   167: goto -52 -> 115
      //
      // Exception table:
      //   from	to	target	type
      //   5	28	92	java/lang/ArrayStoreException
      //   38	63	102	java/lang/ArrayStoreException
    }

    public V remove(Object paramObject)
    {
      return Collections.this.remove(paramObject);
    }

    public int size()
    {
      return Collections.this.size();
    }

    public String toString()
    {
      return Collections.this.toString();
    }

    public Collection<V> values()
    {
      return Collections.this.values();
    }

    class CheckedEntrySet<K, V>
      implements Set<Map.Entry<K, V>>
    {
      Class<V> valueType;

      CheckedEntrySet(Class<V> arg2)
      {
        Object localObject;
        this.valueType = localObject;
      }

      public boolean add(Map.Entry<K, V> paramEntry)
      {
        throw new UnsupportedOperationException();
      }

      public boolean addAll(Collection<? extends Map.Entry<K, V>> paramCollection)
      {
        throw new UnsupportedOperationException();
      }

      public void clear()
      {
        Collections.CheckedMap.this.clear();
      }

      public boolean contains(Object paramObject)
      {
        if (!(paramObject instanceof Map.Entry));
        Set localSet;
        CheckedEntry localCheckedEntry;
        boolean bool;
        for (int i = 0; ; bool = localSet.contains(localCheckedEntry))
        {
          return i;
          localSet = Collections.CheckedMap.this;
          Map.Entry localEntry = (Map.Entry)paramObject;
          Class localClass = this.valueType;
          localCheckedEntry = new CheckedEntry(localClass);
        }
      }

      public boolean containsAll(Collection<?> paramCollection)
      {
        Iterator localIterator = paramCollection.iterator();
        if (!localIterator.hasNext());
        for (int i = 1; ; i = 0)
        {
          return i;
          Object localObject = localIterator.next();
          if (contains(localObject))
            break;
        }
      }

      public boolean equals(Object paramObject)
      {
        int i;
        if (paramObject == this)
          i = 1;
        while (true)
        {
          return i;
          if (!(paramObject instanceof Set))
          {
            i = 0;
            continue;
          }
          Set localSet = (Set)paramObject;
          int j = localSet.size();
          int k = Collections.CheckedMap.this.size();
          if (j != k)
          {
            i = 0;
            continue;
          }
          boolean bool = containsAll(localSet);
        }
      }

      public int hashCode()
      {
        return Collections.CheckedMap.this.hashCode();
      }

      public boolean isEmpty()
      {
        return Collections.CheckedMap.this.isEmpty();
      }

      public Iterator<Map.Entry<K, V>> iterator()
      {
        return new Collections.CheckedMap.CheckedEntrySet.1(this);
      }

      public boolean remove(Object paramObject)
      {
        return Collections.CheckedMap.this.remove(paramObject);
      }

      public boolean removeAll(Collection<?> paramCollection)
      {
        return Collections.CheckedMap.this.removeAll(paramCollection);
      }

      public boolean retainAll(Collection<?> paramCollection)
      {
        return Collections.CheckedMap.this.retainAll(paramCollection);
      }

      public int size()
      {
        return Collections.CheckedMap.this.size();
      }

      public Object[] toArray()
      {
        Object[] arrayOfObject1 = Collections.CheckedMap.this.toArray();
        Class localClass1 = arrayOfObject1.getClass().getComponentType();
        Object[] arrayOfObject2;
        int i;
        if (CheckedEntry.class.isInstance(localClass1))
        {
          arrayOfObject2 = arrayOfObject1;
          i = 0;
        }
        while (true)
        {
          int j = arrayOfObject1.length;
          if (i >= j)
          {
            return arrayOfObject2;
            arrayOfObject2 = new Object[arrayOfObject1.length];
            break;
          }
          Map.Entry localEntry = (Map.Entry)arrayOfObject1[i];
          Class localClass2 = this.valueType;
          CheckedEntry localCheckedEntry = new CheckedEntry(localClass2);
          arrayOfObject2[i] = localCheckedEntry;
          i += 1;
        }
      }

      public <T> T[] toArray(T[] paramArrayOfT)
      {
        Object localObject1 = Collections.CheckedMap.this;
        Object localObject2;
        Object[] arrayOfObject;
        int i;
        if (paramArrayOfT.length == 0)
        {
          localObject2 = paramArrayOfT;
          arrayOfObject = ((Set)localObject1).toArray(localObject2);
          i = 0;
          label24: int j = arrayOfObject.length;
          if (i < j)
            break label66;
          int k = arrayOfObject.length;
          int m = paramArrayOfT.length;
          if (k <= m)
            break label111;
        }
        for (localObject1 = arrayOfObject; ; localObject1 = paramArrayOfT)
        {
          return localObject1;
          localObject2 = Arrays.copyOf(paramArrayOfT, 0);
          break;
          label66: Map.Entry localEntry = (Map.Entry)arrayOfObject[i];
          Class localClass = this.valueType;
          CheckedEntry localCheckedEntry = new CheckedEntry(localClass);
          arrayOfObject[i] = localCheckedEntry;
          i += 1;
          break label24;
          label111: int n = arrayOfObject.length;
          System.arraycopy(arrayOfObject, 0, paramArrayOfT, 0, n);
          int i1 = paramArrayOfT.length;
          int i2 = arrayOfObject.length;
          if (i1 <= i2)
            continue;
          int i3 = arrayOfObject.length;
          paramArrayOfT[i3] = 0;
        }
      }

      public String toString()
      {
        return Collections.CheckedMap.this.toString();
      }

      class CheckedEntry<K, V>
        implements Map.Entry<K, V>
      {
        private Class<V> valueType;

        CheckedEntry(Class<V> arg2)
        {
          Object localObject;
          this.valueType = localObject;
        }

        public boolean equals(Object paramObject)
        {
          int i;
          if (!(paramObject instanceof Map.Entry))
            i = 0;
          while (true)
          {
            return i;
            Map.Entry localEntry = (Map.Entry)paramObject;
            Object localObject1 = Collections.CheckedMap.CheckedEntrySet.this.getKey();
            Object localObject2 = localEntry.getKey();
            if (Collections.access$0(localObject1, localObject2))
            {
              Object localObject3 = Collections.CheckedMap.CheckedEntrySet.this.getValue();
              Object localObject4 = localEntry.getValue();
              if (Collections.access$0(localObject3, localObject4))
              {
                i = 1;
                continue;
              }
            }
            i = 0;
          }
        }

        public K getKey()
        {
          return Collections.CheckedMap.CheckedEntrySet.this.getKey();
        }

        public V getValue()
        {
          return Collections.CheckedMap.CheckedEntrySet.this.getValue();
        }

        public int hashCode()
        {
          return Collections.CheckedMap.CheckedEntrySet.this.hashCode();
        }

        public V setValue(V paramV)
        {
          if (!this.valueType.isInstance(paramV))
          {
            StringBuilder localStringBuilder1 = new StringBuilder("Attempt to insert ");
            Class localClass1 = paramV.getClass();
            StringBuilder localStringBuilder2 = localStringBuilder1.append(localClass1).append(" value into collection with value type ");
            Class localClass2 = this.valueType;
            String str = localClass2;
            throw new ClassCastException(str);
          }
          return Collections.CheckedMap.CheckedEntrySet.this.setValue(paramV);
        }

        public String toString()
        {
          return Collections.CheckedMap.CheckedEntrySet.this.toString();
        }
      }
    }
  }

  class CheckedRandomAccessList<E> extends Collections.CheckedList<E>
    implements RandomAccess
  {
    private static final long serialVersionUID = 1638200125423088369L;

    CheckedRandomAccessList(Class<E> arg2)
    {
      super(localClass);
    }

    public List<E> subList(int paramInt1, int paramInt2)
    {
      List localList = this.list.subList(paramInt1, paramInt2);
      Class localClass = this.type;
      return new CheckedRandomAccessList(localList, localClass);
    }
  }

  class CheckedSet<E> extends Collections.CheckedCollection<E>
    implements Set<E>, Serializable
  {
    private static final long serialVersionUID = 4694047833775013803L;

    CheckedSet(Class<E> arg2)
    {
      super(localClass);
    }

    public boolean equals(Object paramObject)
    {
      if ((paramObject != this) && (!this.c.equals(paramObject)));
      for (int i = 0; ; i = 1)
        return i;
    }

    public int hashCode()
    {
      return this.c.hashCode();
    }
  }

  class CheckedSortedMap<K, V> extends Collections.CheckedMap<K, V>
    implements SortedMap<K, V>, Serializable
  {
    private static final long serialVersionUID = 1599671320688067438L;

    CheckedSortedMap(Class<K> paramClass, Class<V> arg3)
    {
      super(paramClass, localClass);
    }

    public Comparator<? super K> comparator()
    {
      return Collections.this.comparator();
    }

    public K firstKey()
    {
      return Collections.this.firstKey();
    }

    public SortedMap<K, V> headMap(K paramK)
    {
      SortedMap localSortedMap = Collections.this.headMap(paramK);
      Class localClass1 = this.keyType;
      Class localClass2 = this.valueType;
      return new CheckedSortedMap(localSortedMap, localClass1, localClass2);
    }

    public K lastKey()
    {
      return Collections.this.lastKey();
    }

    public SortedMap<K, V> subMap(K paramK1, K paramK2)
    {
      SortedMap localSortedMap = Collections.this.subMap(paramK1, paramK2);
      Class localClass1 = this.keyType;
      Class localClass2 = this.valueType;
      return new CheckedSortedMap(localSortedMap, localClass1, localClass2);
    }

    public SortedMap<K, V> tailMap(K paramK)
    {
      SortedMap localSortedMap = Collections.this.tailMap(paramK);
      Class localClass1 = this.keyType;
      Class localClass2 = this.valueType;
      return new CheckedSortedMap(localSortedMap, localClass1, localClass2);
    }
  }

  class CheckedSortedSet<E> extends Collections.CheckedSet<E>
    implements SortedSet<E>, Serializable
  {
    private static final long serialVersionUID = 1599911165492914959L;

    CheckedSortedSet(Class<E> arg2)
    {
      super(localClass);
    }

    public Comparator<? super E> comparator()
    {
      return Collections.this.comparator();
    }

    public E first()
    {
      return Collections.this.first();
    }

    public SortedSet<E> headSet(E paramE)
    {
      SortedSet localSortedSet = Collections.this.headSet(paramE);
      Class localClass = this.type;
      return new CheckedSortedSet(localSortedSet, localClass);
    }

    public E last()
    {
      return Collections.this.last();
    }

    public SortedSet<E> subSet(E paramE1, E paramE2)
    {
      SortedSet localSortedSet = Collections.this.subSet(paramE1, paramE2);
      Class localClass = this.type;
      return new CheckedSortedSet(localSortedSet, localClass);
    }

    public SortedSet<E> tailSet(E paramE)
    {
      SortedSet localSortedSet = Collections.this.tailSet(paramE);
      Class localClass = this.type;
      return new CheckedSortedSet(localSortedSet, localClass);
    }
  }

  class CopiesList<E> extends AbstractList<E>
    implements RandomAccess, Serializable
  {
    static final long serialVersionUID = 2739099268398711800L;
    final E element;
    final int n;

    static
    {
      if (!Collections.class.desiredAssertionStatus());
      for (int i = 1; ; i = 0)
      {
        $assertionsDisabled = i;
        return;
      }
    }

    CopiesList(E arg2)
    {
      assert (this$1 >= 0);
      this.n = this$1;
      Object localObject;
      this.element = localObject;
    }

    public boolean contains(Object paramObject)
    {
      if (this.n != 0)
      {
        Object localObject = this.element;
        if (!Collections.access$0(paramObject, localObject));
      }
      for (int i = 1; ; i = 0)
        return i;
    }

    public E get(int paramInt)
    {
      if (paramInt >= 0)
      {
        int i = this.n;
        if (paramInt < i);
      }
      else
      {
        StringBuilder localStringBuilder = new StringBuilder("Index: ").append(paramInt).append(", Size: ");
        int j = this.n;
        String str = j;
        throw new IndexOutOfBoundsException(str);
      }
      return this.element;
    }

    public int indexOf(Object paramObject)
    {
      if (contains(paramObject));
      for (int i = 0; ; i = -1)
        return i;
    }

    public int lastIndexOf(Object paramObject)
    {
      if (contains(paramObject));
      for (int i = this.n - 1; ; i = -1)
        return i;
    }

    public int size()
    {
      return this.n;
    }

    public List<E> subList(int paramInt1, int paramInt2)
    {
      if (paramInt1 < 0)
      {
        String str1 = "fromIndex = " + paramInt1;
        throw new IndexOutOfBoundsException(str1);
      }
      int i = this.n;
      if (paramInt2 > i)
      {
        String str2 = "toIndex = " + paramInt2;
        throw new IndexOutOfBoundsException(str2);
      }
      if (paramInt1 > paramInt2)
      {
        String str3 = "fromIndex(" + paramInt1 + ") > toIndex(" + paramInt2 + ")";
        throw new IllegalArgumentException(str3);
      }
      int j = paramInt2 - paramInt1;
      Object localObject = this.element;
      return new CopiesList(j, localObject);
    }

    public Object[] toArray()
    {
      Object[] arrayOfObject = new Object[this.n];
      if (this.element != null)
      {
        int i = this.n;
        Object localObject = this.element;
        Arrays.fill(arrayOfObject, 0, i, localObject);
      }
      return arrayOfObject;
    }

    public <T> T[] toArray(T[] paramArrayOfT)
    {
      int i = this.n;
      if (paramArrayOfT.length < i)
      {
        paramArrayOfT = (Object[])Array.newInstance(paramArrayOfT.getClass().getComponentType(), i);
        if (this.element != null)
        {
          Object localObject1 = this.element;
          Arrays.fill(paramArrayOfT, 0, i, localObject1);
        }
      }
      while (true)
      {
        return paramArrayOfT;
        Object localObject2 = this.element;
        Arrays.fill(paramArrayOfT, 0, i, localObject2);
        if (paramArrayOfT.length <= i)
          continue;
        paramArrayOfT[i] = 0;
      }
    }
  }

  class EmptyList extends AbstractList<Object>
    implements RandomAccess, Serializable
  {
    private static final long serialVersionUID = 8842843931221139166L;

    private Object readResolve()
    {
      return Collections.EMPTY_LIST;
    }

    public boolean contains(Object paramObject)
    {
      return false;
    }

    public Object get(int paramInt)
    {
      String str = "Index: " + paramInt;
      throw new IndexOutOfBoundsException(str);
    }

    public int size()
    {
      return 0;
    }
  }

  class EmptyMap extends AbstractMap<Object, Object>
    implements Serializable
  {
    private static final long serialVersionUID = 6428348081105594320L;

    private Object readResolve()
    {
      return Collections.EMPTY_MAP;
    }

    public boolean containsKey(Object paramObject)
    {
      return false;
    }

    public boolean containsValue(Object paramObject)
    {
      return false;
    }

    public Set<Map.Entry<Object, Object>> entrySet()
    {
      return Collections.emptySet();
    }

    public boolean equals(Object paramObject)
    {
      if (((paramObject instanceof Map)) && (((Map)paramObject).size() == 0));
      for (int i = 1; ; i = 0)
        return i;
    }

    public Object get(Object paramObject)
    {
      return null;
    }

    public int hashCode()
    {
      return 0;
    }

    public boolean isEmpty()
    {
      return true;
    }

    public Set<Object> keySet()
    {
      return Collections.emptySet();
    }

    public int size()
    {
      return 0;
    }

    public Collection<Object> values()
    {
      return Collections.emptySet();
    }
  }

  class EmptySet extends AbstractSet<Object>
    implements Serializable
  {
    private static final long serialVersionUID = 1582296315990362920L;

    private Object readResolve()
    {
      return Collections.EMPTY_SET;
    }

    public boolean contains(Object paramObject)
    {
      return false;
    }

    public Iterator<Object> iterator()
    {
      return new Collections.EmptySet.1(this);
    }

    public int size()
    {
      return 0;
    }
  }

  class ReverseComparator<T>
    implements Comparator<Comparable<Object>>, Serializable
  {
    private static final long serialVersionUID = 7207038068494060240L;

    private Object readResolve()
    {
      return Collections.reverseOrder();
    }

    public int compare(Comparable<Object> paramComparable1, Comparable<Object> paramComparable2)
    {
      return paramComparable2.compareTo(paramComparable1);
    }
  }

  class ReverseComparator2<T>
    implements Comparator<T>, Serializable
  {
    private static final long serialVersionUID = 4374092139857L;

    static
    {
      if (!Collections.class.desiredAssertionStatus());
      for (int i = 1; ; i = 0)
      {
        $assertionsDisabled = i;
        return;
      }
    }

    ReverseComparator2()
    {
      assert (Collections.this != null);
    }

    public int compare(T paramT1, T paramT2)
    {
      return Collections.this.compare(paramT2, paramT1);
    }
  }

  abstract interface SelfComparable extends Comparable<SelfComparable>
  {
  }

  class SetFromMap<E> extends AbstractSet<E>
    implements Set<E>, Serializable
  {
    private static final long serialVersionUID = 2454657854757543876L;
    private transient Set<E> s;

    SetFromMap()
    {
      if (!Collections.this.isEmpty())
        throw new IllegalArgumentException("Map is non-empty");
      Set localSet = Collections.this.keySet();
      this.s = localSet;
    }

    private void readObject(ObjectInputStream paramObjectInputStream)
      throws IOException, ClassNotFoundException
    {
      paramObjectInputStream.defaultReadObject();
      Set localSet = Collections.this.keySet();
      this.s = localSet;
    }

    public boolean add(E paramE)
    {
      Map localMap = Collections.this;
      Boolean localBoolean = Boolean.TRUE;
      if (localMap.put(paramE, localBoolean) == null);
      for (int i = 1; ; i = 0)
        return i;
    }

    public void clear()
    {
      Collections.this.clear();
    }

    public boolean contains(Object paramObject)
    {
      return Collections.this.containsKey(paramObject);
    }

    public boolean containsAll(Collection<?> paramCollection)
    {
      return this.s.containsAll(paramCollection);
    }

    public boolean equals(Object paramObject)
    {
      if ((paramObject != this) && (!this.s.equals(paramObject)));
      for (int i = 0; ; i = 1)
        return i;
    }

    public int hashCode()
    {
      return this.s.hashCode();
    }

    public boolean isEmpty()
    {
      return Collections.this.isEmpty();
    }

    public Iterator<E> iterator()
    {
      return this.s.iterator();
    }

    public boolean remove(Object paramObject)
    {
      if (Collections.this.remove(paramObject) != null);
      for (int i = 1; ; i = 0)
        return i;
    }

    public boolean removeAll(Collection<?> paramCollection)
    {
      return this.s.removeAll(paramCollection);
    }

    public boolean retainAll(Collection<?> paramCollection)
    {
      return this.s.retainAll(paramCollection);
    }

    public int size()
    {
      return Collections.this.size();
    }

    public Object[] toArray()
    {
      return this.s.toArray();
    }

    public <T> T[] toArray(T[] paramArrayOfT)
    {
      return this.s.toArray(paramArrayOfT);
    }

    public String toString()
    {
      return this.s.toString();
    }
  }

  class SingletonList<E> extends AbstractList<E>
    implements RandomAccess, Serializable
  {
    static final long serialVersionUID = 3093736618740652951L;

    SingletonList()
    {
    }

    public boolean contains(Object paramObject)
    {
      Object localObject = Collections.this;
      return Collections.access$0(paramObject, localObject);
    }

    public E get(int paramInt)
    {
      if (paramInt != 0)
      {
        String str = "Index: " + paramInt + ", Size: 1";
        throw new IndexOutOfBoundsException(str);
      }
      return Collections.this;
    }

    public int size()
    {
      return 1;
    }
  }

  class SingletonMap<K, V> extends AbstractMap<K, V>
    implements Serializable
  {
    private static final long serialVersionUID = -6979724477215052911L;
    private transient Set<Map.Entry<K, V>> entrySet = null;
    private transient Set<K> keySet = null;
    private final V v;
    private transient Collection<V> values = null;

    SingletonMap(V arg2)
    {
      Object localObject;
      this.v = localObject;
    }

    public boolean containsKey(Object paramObject)
    {
      Object localObject = Collections.this;
      return Collections.access$0(paramObject, localObject);
    }

    public boolean containsValue(Object paramObject)
    {
      Object localObject = this.v;
      return Collections.access$0(paramObject, localObject);
    }

    public Set<Map.Entry<K, V>> entrySet()
    {
      if (this.entrySet == null)
      {
        Object localObject1 = Collections.this;
        Object localObject2 = this.v;
        Set localSet = Collections.singleton(new AbstractMap.SimpleImmutableEntry(localObject1, localObject2));
        this.entrySet = localSet;
      }
      return this.entrySet;
    }

    public V get(Object paramObject)
    {
      Object localObject1 = Collections.this;
      if (Collections.access$0(paramObject, localObject1));
      for (Object localObject2 = this.v; ; localObject2 = null)
        return localObject2;
    }

    public boolean isEmpty()
    {
      return false;
    }

    public Set<K> keySet()
    {
      if (this.keySet == null)
      {
        Set localSet = Collections.singleton(Collections.this);
        this.keySet = localSet;
      }
      return this.keySet;
    }

    public int size()
    {
      return 1;
    }

    public Collection<V> values()
    {
      if (this.values == null)
      {
        Set localSet = Collections.singleton(this.v);
        this.values = localSet;
      }
      return this.values;
    }
  }

  class SingletonSet<E> extends AbstractSet<E>
    implements Serializable
  {
    private static final long serialVersionUID = 3193687207550431679L;

    SingletonSet()
    {
    }

    public boolean contains(Object paramObject)
    {
      Object localObject = Collections.this;
      return Collections.access$0(paramObject, localObject);
    }

    public Iterator<E> iterator()
    {
      return new Collections.SingletonSet.1(this);
    }

    public int size()
    {
      return 1;
    }
  }

  class SynchronizedCollection<E>
    implements Collection<E>, Serializable
  {
    private static final long serialVersionUID = 3053995032091335093L;
    final Object mutex;

    SynchronizedCollection()
    {
      if (Collections.this == null)
        throw new NullPointerException();
      this.mutex = this;
    }

    SynchronizedCollection(Object arg2)
    {
      Object localObject;
      this.mutex = localObject;
    }

    private void writeObject(ObjectOutputStream paramObjectOutputStream)
      throws IOException
    {
      synchronized (this.mutex)
      {
        paramObjectOutputStream.defaultWriteObject();
        return;
      }
    }

    public boolean add(E paramE)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.add(paramE);
        return bool;
      }
    }

    public boolean addAll(Collection<? extends E> paramCollection)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.addAll(paramCollection);
        return bool;
      }
    }

    public void clear()
    {
      synchronized (this.mutex)
      {
        Collections.this.clear();
        return;
      }
    }

    public boolean contains(Object paramObject)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.contains(paramObject);
        return bool;
      }
    }

    public boolean containsAll(Collection<?> paramCollection)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.containsAll(paramCollection);
        return bool;
      }
    }

    public boolean isEmpty()
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.isEmpty();
        return bool;
      }
    }

    public Iterator<E> iterator()
    {
      return Collections.this.iterator();
    }

    public boolean remove(Object paramObject)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.remove(paramObject);
        return bool;
      }
    }

    public boolean removeAll(Collection<?> paramCollection)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.removeAll(paramCollection);
        return bool;
      }
    }

    public boolean retainAll(Collection<?> paramCollection)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.retainAll(paramCollection);
        return bool;
      }
    }

    public int size()
    {
      synchronized (this.mutex)
      {
        int i = Collections.this.size();
        return i;
      }
    }

    public Object[] toArray()
    {
      synchronized (this.mutex)
      {
        Object[] arrayOfObject = Collections.this.toArray();
        return arrayOfObject;
      }
    }

    public <T> T[] toArray(T[] paramArrayOfT)
    {
      synchronized (this.mutex)
      {
        Object[] arrayOfObject = Collections.this.toArray(paramArrayOfT);
        return arrayOfObject;
      }
    }

    public String toString()
    {
      synchronized (this.mutex)
      {
        String str = Collections.this.toString();
        return str;
      }
    }
  }

  class SynchronizedList<E> extends Collections.SynchronizedCollection<E>
    implements List<E>
  {
    static final long serialVersionUID = -7754090372962971524L;

    SynchronizedList()
    {
      super();
    }

    SynchronizedList(Object arg2)
    {
      super(localObject);
    }

    private Object readResolve()
    {
      List localList;
      if ((Collections.this instanceof RandomAccess))
        localList = Collections.this;
      for (Object localObject = new Collections.SynchronizedRandomAccessList(localList); ; localObject = this)
        return localObject;
    }

    public void add(int paramInt, E paramE)
    {
      synchronized (this.mutex)
      {
        Collections.this.add(paramInt, paramE);
        return;
      }
    }

    public boolean addAll(int paramInt, Collection<? extends E> paramCollection)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.addAll(paramInt, paramCollection);
        return bool;
      }
    }

    public boolean equals(Object paramObject)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.equals(paramObject);
        return bool;
      }
    }

    public E get(int paramInt)
    {
      synchronized (this.mutex)
      {
        Object localObject2 = Collections.this.get(paramInt);
        return localObject2;
      }
    }

    public int hashCode()
    {
      synchronized (this.mutex)
      {
        int i = Collections.this.hashCode();
        return i;
      }
    }

    public int indexOf(Object paramObject)
    {
      synchronized (this.mutex)
      {
        int i = Collections.this.indexOf(paramObject);
        return i;
      }
    }

    public int lastIndexOf(Object paramObject)
    {
      synchronized (this.mutex)
      {
        int i = Collections.this.lastIndexOf(paramObject);
        return i;
      }
    }

    public ListIterator<E> listIterator()
    {
      return Collections.this.listIterator();
    }

    public ListIterator<E> listIterator(int paramInt)
    {
      return Collections.this.listIterator(paramInt);
    }

    public E remove(int paramInt)
    {
      synchronized (this.mutex)
      {
        Object localObject2 = Collections.this.remove(paramInt);
        return localObject2;
      }
    }

    public E set(int paramInt, E paramE)
    {
      synchronized (this.mutex)
      {
        Object localObject2 = Collections.this.set(paramInt, paramE);
        return localObject2;
      }
    }

    public List<E> subList(int paramInt1, int paramInt2)
    {
      synchronized (this.mutex)
      {
        List localList = Collections.this.subList(paramInt1, paramInt2);
        Object localObject2 = this.mutex;
        SynchronizedList localSynchronizedList = new SynchronizedList(localList, localObject2);
        return localSynchronizedList;
      }
    }
  }

  class SynchronizedMap<K, V>
    implements Map<K, V>, Serializable
  {
    private static final long serialVersionUID = 1978198479659022715L;
    private transient Set<Map.Entry<K, V>> entrySet = null;
    private transient Set<K> keySet = null;
    final Object mutex;
    private transient Collection<V> values = null;

    SynchronizedMap()
    {
      if (Collections.this == null)
        throw new NullPointerException();
      this.mutex = this;
    }

    SynchronizedMap(Object arg2)
    {
      Object localObject;
      this.mutex = localObject;
    }

    private void writeObject(ObjectOutputStream paramObjectOutputStream)
      throws IOException
    {
      synchronized (this.mutex)
      {
        paramObjectOutputStream.defaultWriteObject();
        return;
      }
    }

    public void clear()
    {
      synchronized (this.mutex)
      {
        Collections.this.clear();
        return;
      }
    }

    public boolean containsKey(Object paramObject)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.containsKey(paramObject);
        return bool;
      }
    }

    public boolean containsValue(Object paramObject)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.containsValue(paramObject);
        return bool;
      }
    }

    public Set<Map.Entry<K, V>> entrySet()
    {
      synchronized (this.mutex)
      {
        if (this.entrySet == null)
        {
          Set localSet1 = Collections.this.entrySet();
          Object localObject2 = this.mutex;
          Collections.SynchronizedSet localSynchronizedSet = new Collections.SynchronizedSet(localSet1, localObject2);
          this.entrySet = localSynchronizedSet;
        }
        Set localSet2 = this.entrySet;
        return localSet2;
      }
    }

    public boolean equals(Object paramObject)
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.equals(paramObject);
        return bool;
      }
    }

    public V get(Object paramObject)
    {
      synchronized (this.mutex)
      {
        Object localObject2 = Collections.this.get(paramObject);
        return localObject2;
      }
    }

    public int hashCode()
    {
      synchronized (this.mutex)
      {
        int i = Collections.this.hashCode();
        return i;
      }
    }

    public boolean isEmpty()
    {
      synchronized (this.mutex)
      {
        boolean bool = Collections.this.isEmpty();
        return bool;
      }
    }

    public Set<K> keySet()
    {
      synchronized (this.mutex)
      {
        if (this.keySet == null)
        {
          Set localSet1 = Collections.this.keySet();
          Object localObject2 = this.mutex;
          Collections.SynchronizedSet localSynchronizedSet = new Collections.SynchronizedSet(localSet1, localObject2);
          this.keySet = localSynchronizedSet;
        }
        Set localSet2 = this.keySet;
        return localSet2;
      }
    }

    public V put(K paramK, V paramV)
    {
      synchronized (this.mutex)
      {
        Object localObject2 = Collections.this.put(paramK, paramV);
        return localObject2;
      }
    }

    public void putAll(Map<? extends K, ? extends V> paramMap)
    {
      synchronized (this.mutex)
      {
        Collections.this.putAll(paramMap);
        return;
      }
    }

    public V remove(Object paramObject)
    {
      synchronized (this.mutex)
      {
        Object localObject2 = Collections.this.remove(paramObject);
        return localObject2;
      }
    }

    public int size()
    {
      synchronized (this.mutex)
      {
        int i = Collections.this.size();
        return i;
      }
    }

    public String toString()
    {
      synchronized (this.mutex)
      {
        String str = Collections.this.toString();
        return str;
      }
    }

    public Collection<V> values()
    {
      synchronized (this.mutex)
      {
        if (this.values == null)
        {
          Collection localCollection1 = Collections.this.values();
          Object localObject2 = this.mutex;
          Collections.SynchronizedCollection localSynchronizedCollection = new Collections.SynchronizedCollection(localCollection1, localObject2);
          this.values = localSynchronizedCollection;
        }
        Collection localCollection2 = this.values;
        return localCollection2;
      }
    }
  }

  class SynchronizedRandomAccessList<E> extends Collections.SynchronizedList<E>
    implements RandomAccess
  {
    static final long serialVersionUID = 1530674583602358482L;

    SynchronizedRandomAccessList()
    {
      super();
    }

    SynchronizedRandomAccessList(Object arg2)
    {
      super(localObject);
    }

    private Object writeReplace()
    {
      List localList = this.list;
      return new Collections.SynchronizedList(localList);
    }

    public List<E> subList(int paramInt1, int paramInt2)
    {
      synchronized (this.mutex)
      {
        List localList = this.list.subList(paramInt1, paramInt2);
        Object localObject2 = this.mutex;
        SynchronizedRandomAccessList localSynchronizedRandomAccessList = new SynchronizedRandomAccessList(localList, localObject2);
        return localSynchronizedRandomAccessList;
      }
    }
  }

  class SynchronizedSet<E> extends Collections.SynchronizedCollection<E>
    implements Set<E>
  {
    private static final long serialVersionUID = 487447009682186044L;

    SynchronizedSet()
    {
      super();
    }

    SynchronizedSet(Object arg2)
    {
      super(localObject);
    }

    public boolean equals(Object paramObject)
    {
      synchronized (this.mutex)
      {
        boolean bool = this.c.equals(paramObject);
        return bool;
      }
    }

    public int hashCode()
    {
      synchronized (this.mutex)
      {
        int i = this.c.hashCode();
        return i;
      }
    }
  }

  class SynchronizedSortedMap<K, V> extends Collections.SynchronizedMap<K, V>
    implements SortedMap<K, V>
  {
    private static final long serialVersionUID = -8798146769416483793L;

    SynchronizedSortedMap()
    {
      super();
    }

    SynchronizedSortedMap(Object arg2)
    {
      super(localObject);
    }

    public Comparator<? super K> comparator()
    {
      synchronized (this.mutex)
      {
        Comparator localComparator = Collections.this.comparator();
        return localComparator;
      }
    }

    public K firstKey()
    {
      synchronized (this.mutex)
      {
        Object localObject2 = Collections.this.firstKey();
        return localObject2;
      }
    }

    public SortedMap<K, V> headMap(K paramK)
    {
      synchronized (this.mutex)
      {
        SortedMap localSortedMap = Collections.this.headMap(paramK);
        Object localObject2 = this.mutex;
        SynchronizedSortedMap localSynchronizedSortedMap = new SynchronizedSortedMap(localSortedMap, localObject2);
        return localSynchronizedSortedMap;
      }
    }

    public K lastKey()
    {
      synchronized (this.mutex)
      {
        Object localObject2 = Collections.this.lastKey();
        return localObject2;
      }
    }

    public SortedMap<K, V> subMap(K paramK1, K paramK2)
    {
      synchronized (this.mutex)
      {
        SortedMap localSortedMap = Collections.this.subMap(paramK1, paramK2);
        Object localObject2 = this.mutex;
        SynchronizedSortedMap localSynchronizedSortedMap = new SynchronizedSortedMap(localSortedMap, localObject2);
        return localSynchronizedSortedMap;
      }
    }

    public SortedMap<K, V> tailMap(K paramK)
    {
      synchronized (this.mutex)
      {
        SortedMap localSortedMap = Collections.this.tailMap(paramK);
        Object localObject2 = this.mutex;
        SynchronizedSortedMap localSynchronizedSortedMap = new SynchronizedSortedMap(localSortedMap, localObject2);
        return localSynchronizedSortedMap;
      }
    }
  }

  class SynchronizedSortedSet<E> extends Collections.SynchronizedSet<E>
    implements SortedSet<E>
  {
    private static final long serialVersionUID = 8695801310862127406L;

    SynchronizedSortedSet()
    {
      super();
    }

    SynchronizedSortedSet(Object arg2)
    {
      super(localObject);
    }

    public Comparator<? super E> comparator()
    {
      synchronized (this.mutex)
      {
        Comparator localComparator = Collections.this.comparator();
        return localComparator;
      }
    }

    public E first()
    {
      synchronized (this.mutex)
      {
        Object localObject2 = Collections.this.first();
        return localObject2;
      }
    }

    public SortedSet<E> headSet(E paramE)
    {
      synchronized (this.mutex)
      {
        SortedSet localSortedSet = Collections.this.headSet(paramE);
        Object localObject2 = this.mutex;
        SynchronizedSortedSet localSynchronizedSortedSet = new SynchronizedSortedSet(localSortedSet, localObject2);
        return localSynchronizedSortedSet;
      }
    }

    public E last()
    {
      synchronized (this.mutex)
      {
        Object localObject2 = Collections.this.last();
        return localObject2;
      }
    }

    public SortedSet<E> subSet(E paramE1, E paramE2)
    {
      synchronized (this.mutex)
      {
        SortedSet localSortedSet = Collections.this.subSet(paramE1, paramE2);
        Object localObject2 = this.mutex;
        SynchronizedSortedSet localSynchronizedSortedSet = new SynchronizedSortedSet(localSortedSet, localObject2);
        return localSynchronizedSortedSet;
      }
    }

    public SortedSet<E> tailSet(E paramE)
    {
      synchronized (this.mutex)
      {
        SortedSet localSortedSet = Collections.this.tailSet(paramE);
        Object localObject2 = this.mutex;
        SynchronizedSortedSet localSynchronizedSortedSet = new SynchronizedSortedSet(localSortedSet, localObject2);
        return localSynchronizedSortedSet;
      }
    }
  }

  class UnmodifiableCollection<E>
    implements Collection<E>, Serializable
  {
    private static final long serialVersionUID = 1820017752578914078L;

    UnmodifiableCollection()
    {
      if (Collections.this == null)
        throw new NullPointerException();
    }

    public boolean add(E paramE)
    {
      throw new UnsupportedOperationException();
    }

    public boolean addAll(Collection<? extends E> paramCollection)
    {
      throw new UnsupportedOperationException();
    }

    public void clear()
    {
      throw new UnsupportedOperationException();
    }

    public boolean contains(Object paramObject)
    {
      return Collections.this.contains(paramObject);
    }

    public boolean containsAll(Collection<?> paramCollection)
    {
      return Collections.this.containsAll(paramCollection);
    }

    public boolean isEmpty()
    {
      return Collections.this.isEmpty();
    }

    public Iterator<E> iterator()
    {
      return new Collections.UnmodifiableCollection.1(this);
    }

    public boolean remove(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }

    public boolean removeAll(Collection<?> paramCollection)
    {
      throw new UnsupportedOperationException();
    }

    public boolean retainAll(Collection<?> paramCollection)
    {
      throw new UnsupportedOperationException();
    }

    public int size()
    {
      return Collections.this.size();
    }

    public Object[] toArray()
    {
      return Collections.this.toArray();
    }

    public <T> T[] toArray(T[] paramArrayOfT)
    {
      return Collections.this.toArray(paramArrayOfT);
    }

    public String toString()
    {
      return Collections.this.toString();
    }
  }

  class UnmodifiableList<E> extends Collections.UnmodifiableCollection<E>
    implements List<E>
  {
    static final long serialVersionUID = -283967356065247728L;

    UnmodifiableList()
    {
      super();
    }

    private Object readResolve()
    {
      List localList;
      if ((Collections.this instanceof RandomAccess))
        localList = Collections.this;
      for (Object localObject = new Collections.UnmodifiableRandomAccessList(localList); ; localObject = this)
        return localObject;
    }

    public void add(int paramInt, E paramE)
    {
      throw new UnsupportedOperationException();
    }

    public boolean addAll(int paramInt, Collection<? extends E> paramCollection)
    {
      throw new UnsupportedOperationException();
    }

    public boolean equals(Object paramObject)
    {
      if ((paramObject != this) && (!Collections.this.equals(paramObject)));
      for (int i = 0; ; i = 1)
        return i;
    }

    public E get(int paramInt)
    {
      return Collections.this.get(paramInt);
    }

    public int hashCode()
    {
      return Collections.this.hashCode();
    }

    public int indexOf(Object paramObject)
    {
      return Collections.this.indexOf(paramObject);
    }

    public int lastIndexOf(Object paramObject)
    {
      return Collections.this.lastIndexOf(paramObject);
    }

    public ListIterator<E> listIterator()
    {
      return listIterator(0);
    }

    public ListIterator<E> listIterator(int paramInt)
    {
      return new Collections.UnmodifiableList.1(this, paramInt);
    }

    public E remove(int paramInt)
    {
      throw new UnsupportedOperationException();
    }

    public E set(int paramInt, E paramE)
    {
      throw new UnsupportedOperationException();
    }

    public List<E> subList(int paramInt1, int paramInt2)
    {
      List localList = Collections.this.subList(paramInt1, paramInt2);
      return new UnmodifiableList(localList);
    }
  }

  class UnmodifiableMap<K, V>
    implements Map<K, V>, Serializable
  {
    private static final long serialVersionUID = -1034234728574286014L;
    private transient Set<Map.Entry<K, V>> entrySet = null;
    private transient Set<K> keySet = null;
    private transient Collection<V> values = null;

    UnmodifiableMap()
    {
      if (Collections.this == null)
        throw new NullPointerException();
    }

    public void clear()
    {
      throw new UnsupportedOperationException();
    }

    public boolean containsKey(Object paramObject)
    {
      return Collections.this.containsKey(paramObject);
    }

    public boolean containsValue(Object paramObject)
    {
      return Collections.this.containsValue(paramObject);
    }

    public Set<Map.Entry<K, V>> entrySet()
    {
      if (this.entrySet == null)
      {
        Set localSet = Collections.this.entrySet();
        UnmodifiableEntrySet localUnmodifiableEntrySet = new UnmodifiableEntrySet();
        this.entrySet = localUnmodifiableEntrySet;
      }
      return this.entrySet;
    }

    public boolean equals(Object paramObject)
    {
      if ((paramObject != this) && (!Collections.this.equals(paramObject)));
      for (int i = 0; ; i = 1)
        return i;
    }

    public V get(Object paramObject)
    {
      return Collections.this.get(paramObject);
    }

    public int hashCode()
    {
      return Collections.this.hashCode();
    }

    public boolean isEmpty()
    {
      return Collections.this.isEmpty();
    }

    public Set<K> keySet()
    {
      if (this.keySet == null)
      {
        Set localSet = Collections.unmodifiableSet(Collections.this.keySet());
        this.keySet = localSet;
      }
      return this.keySet;
    }

    public V put(K paramK, V paramV)
    {
      throw new UnsupportedOperationException();
    }

    public void putAll(Map<? extends K, ? extends V> paramMap)
    {
      throw new UnsupportedOperationException();
    }

    public V remove(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }

    public int size()
    {
      return Collections.this.size();
    }

    public String toString()
    {
      return Collections.this.toString();
    }

    public Collection<V> values()
    {
      if (this.values == null)
      {
        Collection localCollection = Collections.unmodifiableCollection(Collections.this.values());
        this.values = localCollection;
      }
      return this.values;
    }

    class UnmodifiableEntrySet<K, V> extends Collections.UnmodifiableSet<Map.Entry<K, V>>
    {
      private static final long serialVersionUID = 7854390611657943733L;

      UnmodifiableEntrySet()
      {
        super();
      }

      public boolean contains(Object paramObject)
      {
        if (!(paramObject instanceof Map.Entry));
        Collection localCollection;
        UnmodifiableEntry localUnmodifiableEntry;
        boolean bool;
        for (int i = 0; ; bool = localCollection.contains(localUnmodifiableEntry))
        {
          return i;
          localCollection = this.c;
          Map.Entry localEntry = (Map.Entry)paramObject;
          localUnmodifiableEntry = new UnmodifiableEntry();
        }
      }

      public boolean containsAll(Collection<?> paramCollection)
      {
        Iterator localIterator = paramCollection.iterator();
        if (!localIterator.hasNext());
        for (int i = 1; ; i = 0)
        {
          return i;
          Object localObject = localIterator.next();
          if (contains(localObject))
            break;
        }
      }

      public boolean equals(Object paramObject)
      {
        int i;
        if (paramObject == this)
          i = 1;
        while (true)
        {
          return i;
          if (!(paramObject instanceof Set))
          {
            i = 0;
            continue;
          }
          Set localSet = (Set)paramObject;
          int j = localSet.size();
          int k = this.c.size();
          if (j != k)
          {
            i = 0;
            continue;
          }
          boolean bool = containsAll(localSet);
        }
      }

      public Iterator<Map.Entry<K, V>> iterator()
      {
        return new Collections.UnmodifiableMap.UnmodifiableEntrySet.1(this);
      }

      public Object[] toArray()
      {
        Object[] arrayOfObject = this.c.toArray();
        int i = 0;
        while (true)
        {
          int j = arrayOfObject.length;
          if (i >= j)
            return arrayOfObject;
          Map.Entry localEntry = (Map.Entry)arrayOfObject[i];
          UnmodifiableEntry localUnmodifiableEntry = new UnmodifiableEntry();
          arrayOfObject[i] = localUnmodifiableEntry;
          i += 1;
        }
      }

      public <T> T[] toArray(T[] paramArrayOfT)
      {
        Object localObject1 = this.c;
        Object localObject2;
        Object[] arrayOfObject;
        int i;
        if (paramArrayOfT.length == 0)
        {
          localObject2 = paramArrayOfT;
          arrayOfObject = ((Collection)localObject1).toArray(localObject2);
          i = 0;
          label24: int j = arrayOfObject.length;
          if (i < j)
            break label66;
          int k = arrayOfObject.length;
          int m = paramArrayOfT.length;
          if (k <= m)
            break label103;
        }
        for (localObject1 = arrayOfObject; ; localObject1 = paramArrayOfT)
        {
          return localObject1;
          localObject2 = Arrays.copyOf(paramArrayOfT, 0);
          break;
          label66: Map.Entry localEntry = (Map.Entry)arrayOfObject[i];
          UnmodifiableEntry localUnmodifiableEntry = new UnmodifiableEntry();
          arrayOfObject[i] = localUnmodifiableEntry;
          i += 1;
          break label24;
          label103: int n = arrayOfObject.length;
          System.arraycopy(arrayOfObject, 0, paramArrayOfT, 0, n);
          int i1 = paramArrayOfT.length;
          int i2 = arrayOfObject.length;
          if (i1 <= i2)
            continue;
          int i3 = arrayOfObject.length;
          paramArrayOfT[i3] = 0;
        }
      }

      class UnmodifiableEntry<K, V>
        implements Map.Entry<K, V>
      {
        UnmodifiableEntry()
        {
        }

        public boolean equals(Object paramObject)
        {
          int i;
          if (!(paramObject instanceof Map.Entry))
            i = 0;
          while (true)
          {
            return i;
            Map.Entry localEntry = (Map.Entry)paramObject;
            Object localObject1 = Collections.UnmodifiableMap.UnmodifiableEntrySet.this.getKey();
            Object localObject2 = localEntry.getKey();
            if (Collections.access$0(localObject1, localObject2))
            {
              Object localObject3 = Collections.UnmodifiableMap.UnmodifiableEntrySet.this.getValue();
              Object localObject4 = localEntry.getValue();
              if (Collections.access$0(localObject3, localObject4))
              {
                i = 1;
                continue;
              }
            }
            i = 0;
          }
        }

        public K getKey()
        {
          return Collections.UnmodifiableMap.UnmodifiableEntrySet.this.getKey();
        }

        public V getValue()
        {
          return Collections.UnmodifiableMap.UnmodifiableEntrySet.this.getValue();
        }

        public int hashCode()
        {
          return Collections.UnmodifiableMap.UnmodifiableEntrySet.this.hashCode();
        }

        public V setValue(V paramV)
        {
          throw new UnsupportedOperationException();
        }

        public String toString()
        {
          return Collections.UnmodifiableMap.UnmodifiableEntrySet.this.toString();
        }
      }
    }
  }

  class UnmodifiableRandomAccessList<E> extends Collections.UnmodifiableList<E>
    implements RandomAccess
  {
    private static final long serialVersionUID = -2542308836966382001L;

    UnmodifiableRandomAccessList()
    {
      super();
    }

    private Object writeReplace()
    {
      List localList = this.list;
      return new Collections.UnmodifiableList(localList);
    }

    public List<E> subList(int paramInt1, int paramInt2)
    {
      List localList = this.list.subList(paramInt1, paramInt2);
      return new UnmodifiableRandomAccessList(localList);
    }
  }

  class UnmodifiableSet<E> extends Collections.UnmodifiableCollection<E>
    implements Set<E>, Serializable
  {
    private static final long serialVersionUID = -9215047833775013803L;

    UnmodifiableSet()
    {
      super();
    }

    public boolean equals(Object paramObject)
    {
      if ((paramObject != this) && (!this.c.equals(paramObject)));
      for (int i = 0; ; i = 1)
        return i;
    }

    public int hashCode()
    {
      return this.c.hashCode();
    }
  }

  class UnmodifiableSortedMap<K, V> extends Collections.UnmodifiableMap<K, V>
    implements SortedMap<K, V>, Serializable
  {
    private static final long serialVersionUID = -8806743815996713206L;

    UnmodifiableSortedMap()
    {
      super();
    }

    public Comparator<? super K> comparator()
    {
      return Collections.this.comparator();
    }

    public K firstKey()
    {
      return Collections.this.firstKey();
    }

    public SortedMap<K, V> headMap(K paramK)
    {
      SortedMap localSortedMap = Collections.this.headMap(paramK);
      return new UnmodifiableSortedMap(localSortedMap);
    }

    public K lastKey()
    {
      return Collections.this.lastKey();
    }

    public SortedMap<K, V> subMap(K paramK1, K paramK2)
    {
      SortedMap localSortedMap = Collections.this.subMap(paramK1, paramK2);
      return new UnmodifiableSortedMap(localSortedMap);
    }

    public SortedMap<K, V> tailMap(K paramK)
    {
      SortedMap localSortedMap = Collections.this.tailMap(paramK);
      return new UnmodifiableSortedMap(localSortedMap);
    }
  }

  class UnmodifiableSortedSet<E> extends Collections.UnmodifiableSet<E>
    implements SortedSet<E>, Serializable
  {
    private static final long serialVersionUID = -4929149591599911165L;

    UnmodifiableSortedSet()
    {
      super();
    }

    public Comparator<? super E> comparator()
    {
      return Collections.this.comparator();
    }

    public E first()
    {
      return Collections.this.first();
    }

    public SortedSet<E> headSet(E paramE)
    {
      SortedSet localSortedSet = Collections.this.headSet(paramE);
      return new UnmodifiableSortedSet(localSortedSet);
    }

    public E last()
    {
      return Collections.this.last();
    }

    public SortedSet<E> subSet(E paramE1, E paramE2)
    {
      SortedSet localSortedSet = Collections.this.subSet(paramE1, paramE2);
      return new UnmodifiableSortedSet(localSortedSet);
    }

    public SortedSet<E> tailSet(E paramE)
    {
      SortedSet localSortedSet = Collections.this.tailSet(paramE);
      return new UnmodifiableSortedSet(localSortedSet);
    }
  }
}

/* Location:           D:\Program Files\eclipse\apktool-r01-3\新浪微博\classes.dex.dex2jar.jar
 * Qualified Name:     sudroid.java.util.Collections
 * JD-Core Version:    0.6.0
 */